package com.xforceplus.bsstool.compare;

import com.alibaba.fastjson.JSON;
import com.xforceplus.bsstool.config.ConfigMain;
import com.xforceplus.bsstool.log.LogMain;
import com.xforceplus.bsstool.service.*;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class CoopCompare {
  public static void main(String[] args) throws Exception {
    //输出日志: INFO(一般运行日志)   WARN（待迁移解决）   ERROR（比对异常）
    LogMain logger = new LogMain();
    logger.startLog("custom");
    //4   比对购销方租户信息及协同关系
    //4.1 获取老运营所有购方租户列表，与新运营比对
    List<Map> oldPurchaserTenantList = ServiceStep4.getOldTenantList(ConfigMain.PURCHASER_TENANT_IDS,logger);
    logger.info("获取老运营购方租户列表："+ JSON.toJSONString(oldPurchaserTenantList));
    if(!ServiceStep4.compareTenantWithNew(oldPurchaserTenantList,ConfigMain.PURCHASER_TENANT_IDS,logger)){
      System.out.println("errorCount:"+logger.getErrorCount());
      if (ConfigMain.STOP_ON_ERROR) {
        logger.info("4.1 检测到严重错误，停止执行！");
        logger.endLog();
        return;
      }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
        logger.info("4.1 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
        logger.endLog();
        return;
      }else{
        logger.info("4.1 检测到严重错误，但继续执行！");
      }
    }
    //4.2 遍历购方，获取购销协同关系和协同销方租户，与新运营比对
    for (Map purchaserTenant : oldPurchaserTenantList){
      List<Long> sellerTenantIds = new ArrayList<>();//协同销方租户ID列表
      System.out.println("执行购方"+purchaserTenant.get("group_code")+" "+purchaserTenant.get("group_name")+" 协同关系校验");
      logger.info("执行购方"+purchaserTenant.get("group_code")+" "+purchaserTenant.get("group_name")+" 协同关系校验");
      List<Map> oldTenantCoopList = ServiceStep4.getOldTenantCoopList(purchaserTenant.get("group_id"),logger);
      logger.info("获取老运营购方租户协同关系列表："+ JSON.toJSONString(oldTenantCoopList));
      if(!ServiceStep4.compareTenantCoopWithNew(oldTenantCoopList,purchaserTenant.get("group_id"),logger)){
        System.out.println("errorCount:"+logger.getErrorCount());
        if (ConfigMain.STOP_ON_ERROR) {
          logger.info("4.2.1 检测到严重错误，停止执行！");
          logger.endLog();
          return;
        }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
          logger.info("4.2.1 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
          logger.endLog();
          return;
        }else {
          logger.info("4.2.1 检测到严重错误，但继续执行！");
        }
      }
      //根据协同关系获取所有协同销方租户ID
      for (Map oldTenantCoop: oldTenantCoopList){
        sellerTenantIds.add(Long.valueOf(String.valueOf(oldTenantCoop.get("seller_group_id"))));
      }
      if (!CollectionUtils.isEmpty(sellerTenantIds)){
        System.out.println("开始处理销方信息,比对销方租户信息");
        logger.info("开始处理销方信息，比对销方租户信息");
        List<Map> oldSellerTenantList = ServiceStep4.getOldTenantList(sellerTenantIds,logger);
        logger.info("获取老运营销方租户列表："+ JSON.toJSONString(oldSellerTenantList));
        if(!ServiceStep4.compareTenantWithNew(oldSellerTenantList,sellerTenantIds,logger)){
          System.out.println("errorCount:"+logger.getErrorCount());
          if (ConfigMain.STOP_ON_ERROR) {
            logger.info("4.2.2 检测到严重错误，停止执行！");
            logger.endLog();
            return;
          }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
            logger.info("4.2.2 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
            logger.endLog();
            return;
          }else {
            logger.info("4.2.2 检测到严重错误，但继续执行！");
          }
        }
        //调用其他销方信息
        if(!dealSellerInfo(sellerTenantIds,logger)){
          System.out.println("errorCount:"+logger.getErrorCount());
          if (ConfigMain.STOP_ON_ERROR) {
            return;
          }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
            return;
          } else {
            continue;
          }
        }
      }else {
        System.out.println("协同销方租户ID列表为空 purchaserTenantInfo:"+JSON.toJSONString(purchaserTenant));
        logger.info("协同销方租户ID列表为空 purchaserTenantInfo:"+JSON.toJSONString(purchaserTenant));
      }
    }

    logger.endLog();
  }

  public static boolean dealSellerInfo(List<Long> sellerTenantIds,LogMain logger) throws Exception {
    for (Long sellerTenantId : sellerTenantIds) {
      //5   比对销方公司信息及公司服务包
      //5.1 遍历销方，获取租户和公司关系，与新运营比对
      List<Map> oldTenantCompanyRelList = ServiceStep5.getOldTenantCompanyRelList(sellerTenantId, logger);
      logger.info("获取老运营租户公司列表：" + JSON.toJSONString(oldTenantCompanyRelList));
      if (!ServiceStep5.compareTenantCompanyRelWithNew(oldTenantCompanyRelList,sellerTenantId, logger)) {
        System.out.println("errorCount:"+logger.getErrorCount());
        if (ConfigMain.STOP_ON_ERROR) {
          logger.info("5.1 检测到严重错误，停止执行！");
          logger.endLog();
          return false;
        }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
          logger.info("5.1 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
          logger.endLog();
          return false;
        } else {
          logger.info("5.1 检测到严重错误，但继续执行！");
        }
      }
      //5.2 遍历销方公司，与新运营比对
      List<Long> sellerCompanyIdList = new ArrayList<>();
      for (Map oldTenantCompanyRel : oldTenantCompanyRelList ){
        sellerCompanyIdList.add(Long.valueOf(String.valueOf(oldTenantCompanyRel.get("company_id"))));
      }
      List<Map> oldCompanyRelList = ServiceStep5.getOldCompanyList(sellerCompanyIdList, logger);
      logger.info("获取老运营公司列表：" + JSON.toJSONString(oldCompanyRelList));
      if (!ServiceStep5.compareCompanyWithNew(oldCompanyRelList,sellerCompanyIdList, logger)) {
        System.out.println("errorCount:"+logger.getErrorCount());
        if (ConfigMain.STOP_ON_ERROR) {
          logger.info("5.2 检测到严重错误，停止执行！");
          logger.endLog();
          return false;
        }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
          logger.info("5.2 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
          logger.endLog();
          return false;
        } else {
          logger.info("5.2 检测到严重错误，但继续执行！");
        }
      }
      //5.3 遍历公司服务包，与新运营比对
      for (Long sellerCompanyId: sellerCompanyIdList){
        List<Map> oldCompanyServiceRelList = ServiceStep5.getOldCompanyServiceRelList(sellerTenantId,sellerCompanyId, logger);
        logger.info("获取老运营公司服务包关联关系列表：" + JSON.toJSONString(oldCompanyServiceRelList));
        if (!ServiceStep5.compareCompanyServiceRelWithNew(oldCompanyServiceRelList,sellerTenantId,sellerCompanyId, logger)) {
          System.out.println("errorCount:"+logger.getErrorCount());
          if (ConfigMain.STOP_ON_ERROR) {
            logger.info("5.3 检测到严重错误，停止执行！");
            logger.endLog();
            return false;
          }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
            logger.info("5.3 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
            logger.endLog();
            return false;
          } else {
            logger.info("5.3 检测到严重错误，但继续执行！");
          }
        }
        if (!dealSellerCompanyInfo(sellerTenantId,sellerCompanyId,logger)){
          System.out.println("errorCount:"+logger.getErrorCount());
          if (ConfigMain.STOP_ON_ERROR) {
            return false;
          }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
            return false;
          } else {
            continue;
          }
        }
      }
    }
    return true;
  }

  public static boolean dealSellerCompanyInfo(Long tenantId,Long companyId,LogMain logger) throws Exception {
    //6   比对销方组织及组织和人员绑定关系
    //6.1 获取所有老运营公司组织，与新运营比对
    List<Map> oldOrgStructList = ServiceStep6.getOldOrgStructList(tenantId,companyId,logger);
    logger.info("获取老运营组织机构列表："+ JSON.toJSONString(oldOrgStructList));
    if(!ServiceStep6.compareOrgStructWithNew(oldOrgStructList,tenantId,companyId,logger)){
      System.out.println("errorCount:"+logger.getErrorCount());
      if (ConfigMain.STOP_ON_ERROR) {
        logger.info("6.1 检测到严重错误，停止执行！");
        logger.endLog();
        return false;
      }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
        logger.info("6.1 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
        logger.endLog();
        return false;
      }else {
        logger.info("6.1 检测到严重错误，但继续执行！");
      }
    }
    //6.2 比对公司组织和人员绑定关系，找不到报WARN信息，不正确报ERROR信息
    List<Map> oldOrgUserRelList = ServiceStep6.getOldOrgUserRelList(tenantId,companyId,logger);
    logger.info("获取老运营组织人员关系列表："+ JSON.toJSONString(oldOrgUserRelList));
    if(!ServiceStep6.compareOrgUserRelWithNew(oldOrgUserRelList,tenantId,companyId,logger)){
      System.out.println("errorCount:"+logger.getErrorCount());
      if (ConfigMain.STOP_ON_ERROR) {
        logger.info("6.2 检测到严重错误，停止执行！");
        logger.endLog();
        return false;
      }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
        logger.info("6.2 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
        logger.endLog();
        return false;
      }else {
        logger.info("6.2 检测到严重错误，但继续执行！");
      }
    }
    //6.3 根据租户ID找到新运营根组织，找不到报WARN信息
    //TODO
    //6.4 根据租户ID和公司ID找到新运营公司组织，找不到报WARN信息
    //TODO
    //6.5 比对6.3和6.4组织关系是否正确，不正确报ERROR信息
    //TODO


    //7   比对销方租户角色及角色和功能集绑定关系
    //7.1 获取老运营销方租户下所有角色，与新运营比对
    List<Map> oldRoleList = ServiceStep7.getOldRoleList(tenantId,logger);
    logger.info("获取老运营角色列表："+ JSON.toJSONString(oldRoleList));
    if(!ServiceStep7.compareRoleWithNew(oldRoleList,tenantId,logger)){
      System.out.println("errorCount:"+logger.getErrorCount());
      if (ConfigMain.STOP_ON_ERROR) {
        logger.info("7.1 检测到严重错误，停止执行！");
        logger.endLog();
        return false;
      }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
        logger.info("7.1 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
        logger.endLog();
        return false;
      }else {
        logger.info("7.1 检测到严重错误，但继续执行！");
      }
    }
    //7.2 获取老运营销方租户下所有角色与功能集关系，与新运营比对
    for (Map oldRoleMap : oldRoleList ) {
      Long roleId = Long.valueOf(String.valueOf(oldRoleMap.get("role_id")));
      //7.2.0
      List<Map> oldRoleResourceSetRelList = ServiceStep7.getOldRoleResourceSetRelList(tenantId, roleId, logger);
      logger.info("获取老运营角色功能集关系列表：" + JSON.toJSONString(oldRoleResourceSetRelList));
      if (!ServiceStep7.compareRoleResourceSetRelWithNew(oldRoleResourceSetRelList, tenantId, roleId, logger)) {
        System.out.println("errorCount:"+logger.getErrorCount());
        if (ConfigMain.STOP_ON_ERROR) {
          logger.info("7.2.0 检测到严重错误，停止执行！");
          logger.endLog();
          return false;
        }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
          logger.info("7.2.0 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
          logger.endLog();
          return false;
        } else {
          logger.info("7.2.0 检测到严重错误，但继续执行！");
        }
      }
      //7.2.1 获取老运营销方租户下所有角色与用户关系，与新运营比对
      List<Map> oldRoleUserRelList = ServiceStep7.getOldRoleUserRelList(tenantId, roleId, logger);
      logger.info("获取老运营角色人员关系列表：" + JSON.toJSONString(oldRoleUserRelList));
      if (!ServiceStep7.compareRoleUserRelWithNew(oldRoleUserRelList, tenantId, roleId, logger)) {
        System.out.println("errorCount:"+logger.getErrorCount());
        if (ConfigMain.STOP_ON_ERROR) {
          logger.info("7.2.1 检测到严重错误，停止执行！");
          logger.endLog();
          return false;
        }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
          logger.info("7.2.1 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
          logger.endLog();
          return false;
        } else {
          logger.info("7.2.1 检测到严重错误，但继续执行！");
        }
      }
    }


    //8   比对销方租户用户、用户和角色关系、用户与账户关系
    //8.1 获取老运营销方租户下所有用户，与新运营比对
    List<Map> oldUserList = ServiceStep8.getOldUserList(tenantId,logger);
    logger.info("获取老运营用户列表："+ JSON.toJSONString(oldUserList));
    if(!ServiceStep8.compareUserWithNew(oldUserList,tenantId,logger)){
      System.out.println("errorCount:"+logger.getErrorCount());
      if (ConfigMain.STOP_ON_ERROR) {
        logger.info("8.1 检测到严重错误，停止执行！");
        logger.endLog();
        return false;
      }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
        logger.info("5.1 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
        logger.endLog();
        return false;
      }else {
        logger.info("8.1 检测到严重错误，但继续执行！");
      }
    }
    //8.2 获取老运营销方租户下所有用户与角色关系，与新运营比对
    for (Map oldUserMap : oldUserList ) {
      Long userId = Long.valueOf(String.valueOf(oldUserMap.get("user_id")));
      //8.2.0
      List<Map> oldRoleUserRelList = ServiceStep8.getOldRoleUserRelList(tenantId, userId, logger);
      logger.info("获取老运营用户角色关系列表：" + JSON.toJSONString(oldRoleUserRelList));
      if (!ServiceStep8.compareRoleUserRelWithNew(oldRoleUserRelList, tenantId, userId, logger)) {
        System.out.println("errorCount:"+logger.getErrorCount());
        if (ConfigMain.STOP_ON_ERROR) {
          logger.info("8.2.0 检测到严重错误，停止执行！");
          logger.endLog();
          return false;
        }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
          logger.info("8.2.0 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
          logger.endLog();
          return false;
        } else {
          logger.info("8.2.0 检测到严重错误，但继续执行！");
        }
      }
      Long accountId = Long.valueOf(String.valueOf(oldUserMap.get("account_id")));
      //8.2.1  获取用户账户信息，与新运营比对
      List<Map> oldSassAccountList = ServiceStep8.getOldSassAccountList(accountId, logger);
      logger.info("获取老运营账户列表：" + JSON.toJSONString(oldSassAccountList));
      if (!ServiceStep8.compareSassAccountWithNew(oldSassAccountList, accountId, logger)) {
        System.out.println("errorCount:"+logger.getErrorCount());
        if (ConfigMain.STOP_ON_ERROR) {
          logger.info("8.2.1 检测到严重错误，停止执行！");
          logger.endLog();
          return false;
        }else if (logger.getErrorCount()>ConfigMain.MAX_ERROR_LOG_COUNT){
          logger.info("8.2.1 检测到错误日志超出最大值"+ConfigMain.MAX_ERROR_LOG_COUNT+"，停止执行！");
          logger.endLog();
          return false;
        } else {
          logger.info("8.2.1 检测到严重错误，但继续执行！");
        }
      }
    }
    return true;
  }
}
